/***************************************************************************
prim.c  -  description
-------------------
begin                : Sun Oct 28 2001
copyright            : (C) 2001 by Pete Bernert
email                : BlackDove@addcom.de
***************************************************************************/
/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version. See also the license.txt file for *
*   additional informations.                                              *
*                                                                         *
***************************************************************************/

#define _IN_PRIMDRAW

#include "externals.h"
#include "gpu.h"
#include "draw.h"
#include "soft.h"
#include "swap.h"

////////////////////////////////////////////////////////////////////////
// globals
////////////////////////////////////////////////////////////////////////

BOOL           bUsingTWin=FALSE;
TWin_t         TWin;
//unsigned long  clutid;                                 // global clut
unsigned short usMirror=0;                             // sprite mirror
int            iDither=0;
int32_t        drawX;
int32_t        drawY;
int32_t        drawW;
int32_t        drawH;
uint32_t       dwCfgFixes;
uint32_t       dwActFixes=0;
uint32_t       dwEmuFixes=0;
int            iUseFixes;
int            iUseDither=0;
BOOL           bDoVSyncUpdate=FALSE;

////////////////////////////////////////////////////////////////////////
// Some ASM color convertion by LEWPY
////////////////////////////////////////////////////////////////////////

#ifdef USE_NASM

#define BGR24to16 i386_BGR24to16
__inline unsigned short BGR24to16 (uint32_t BGR);

#else

__inline unsigned short BGR24to16 (uint32_t BGR)
{
	return (unsigned short)(((BGR>>3)&0x1f)|((BGR&0xf80000)>>9)|((BGR&0xf800)>>6));
}

#endif

////////////////////////////////////////////////////////////////////////
// Update global TP infos
////////////////////////////////////////////////////////////////////////

__inline void UpdateGlobalTP(unsigned short gdata)
{
	GlobalTextAddrX = (gdata << 6) & 0x3c0;               // texture addr

	if(iGPUHeight==1024)
	{
		if(dwGPUVersion==2)
		{
			GlobalTextAddrY =((gdata & 0x60 ) << 3);
			GlobalTextIL    =(gdata & 0x2000) >> 13;
			GlobalTextABR = (unsigned short)((gdata >> 7) & 0x3);
			GlobalTextTP = (gdata >> 9) & 0x3;
			if(GlobalTextTP==3) GlobalTextTP=2;
			usMirror =0;
			lGPUstatusRet = (lGPUstatusRet & 0xffffe000 ) | (gdata & 0x1fff );

			// tekken dithering? right now only if dithering is forced by user
			if(iUseDither==2) iDither=2; else iDither=0;

			return;
		}
		else
		{
			GlobalTextAddrY = (unsigned short)(((gdata << 4) & 0x100) | ((gdata >> 2) & 0x200));
		}
	}
	else GlobalTextAddrY = (gdata << 4) & 0x100;

	GlobalTextTP = (gdata >> 7) & 0x3;                    // tex mode (4,8,15)

	if(GlobalTextTP==3) GlobalTextTP=2;                   // seen in Wild9 :(

	GlobalTextABR = (gdata >> 5) & 0x3;                   // blend mode

	lGPUstatusRet&=~0x000001ff;                           // Clear the necessary bits
	lGPUstatusRet|=(gdata & 0x01ff);                      // set the necessary bits

	switch(iUseDither)
	{
	case 0:
		iDither=0;
		break;
	case 1:
		if(lGPUstatusRet&0x0200) iDither=2;
		else iDither=0;
		break;
	case 2:
		iDither=2;
		break;
	}
}

////////////////////////////////////////////////////////////////////////

__inline void SetRenderMode(uint32_t DrawAttributes)
{
	DrawSemiTrans = (SEMITRANSBIT(DrawAttributes)) ? TRUE : FALSE;

	if(SHADETEXBIT(DrawAttributes)) 
	{g_m1=g_m2=g_m3=128;}
	else
	{
		if((dwActFixes&4) && ((DrawAttributes&0x00ffffff)==0))
			DrawAttributes|=0x007f7f7f;

		g_m1=(short)(DrawAttributes&0xff);
		g_m2=(short)((DrawAttributes>>8)&0xff);
		g_m3=(short)((DrawAttributes>>16)&0xff);
	}
}

////////////////////////////////////////////////////////////////////////

// oki, here are the psx gpu coord rules: poly coords are
// 11 bit signed values (-1024...1023). If the x or y distance 
// exceeds 1024, the polygon will not be drawn. 
// Since quads are treated as two triangles by the real gpu,
// this 'discard rule' applies to each of the quad's triangle 
// (so one triangle can be drawn, the other one discarded). 
// Also, y drawing is wrapped at 512 one time,
// then it will get negative (and therefore not drawn). The
// 'CheckCoord' funcs are a simple (not comlete!) approach to
// do things right, I will add a better detection soon... the 
// current approach will be easier to do in hw/accel plugins, imho

// 11 bit signed
#define SIGNSHIFT 21
#define CHKMAX_X 1024
#define CHKMAX_Y 512

void AdjustCoord4()
{
	lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
	lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
	lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);
	lx3=(short)(((int)lx3<<SIGNSHIFT)>>SIGNSHIFT);
	ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
	ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
	ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);
	ly3=(short)(((int)ly3<<SIGNSHIFT)>>SIGNSHIFT);
}

void AdjustCoord3()
{
	lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
	lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
	lx2=(short)(((int)lx2<<SIGNSHIFT)>>SIGNSHIFT);
	ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
	ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
	ly2=(short)(((int)ly2<<SIGNSHIFT)>>SIGNSHIFT);
}

void AdjustCoord2()
{
	lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
	lx1=(short)(((int)lx1<<SIGNSHIFT)>>SIGNSHIFT);
	ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);
	ly1=(short)(((int)ly1<<SIGNSHIFT)>>SIGNSHIFT);
}

void AdjustCoord1()
{
	lx0=(short)(((int)lx0<<SIGNSHIFT)>>SIGNSHIFT);
	ly0=(short)(((int)ly0<<SIGNSHIFT)>>SIGNSHIFT);

	if(lx0<-512 && PSXDisplay.DrawOffset.x<=-512)
		lx0+=2048;

	if(ly0<-512 && PSXDisplay.DrawOffset.y<=-512)
		ly0+=2048;
}

////////////////////////////////////////////////////////////////////////
// special checks... nascar, syphon filter 2, mgs
////////////////////////////////////////////////////////////////////////

// xenogears FT4: not removed correctly right now... the tri 0,1,2
// should get removed, the tri 1,2,3 should stay... pfff

// x -466 1023 180 1023
// y   20 -228 222 -100

// 0 __1
//  \ / \ 
//   2___3

__inline BOOL CheckCoord4()
{
	if(lx0<0)
	{
		if(((lx1-lx0)>CHKMAX_X) ||
			((lx2-lx0)>CHKMAX_X)) 
		{
			if(lx3<0)
			{
				if((lx1-lx3)>CHKMAX_X) return TRUE;
				if((lx2-lx3)>CHKMAX_X) return TRUE;
			}
		}
	}
	if(lx1<0)
	{
		if((lx0-lx1)>CHKMAX_X) return TRUE;
		if((lx2-lx1)>CHKMAX_X) return TRUE;
		if((lx3-lx1)>CHKMAX_X) return TRUE;
	}
	if(lx2<0)
	{
		if((lx0-lx2)>CHKMAX_X) return TRUE;
		if((lx1-lx2)>CHKMAX_X) return TRUE;
		if((lx3-lx2)>CHKMAX_X) return TRUE;
	}
	if(lx3<0)
	{
		if(((lx1-lx3)>CHKMAX_X) ||
			((lx2-lx3)>CHKMAX_X))
		{
			if(lx0<0)
			{
				if((lx1-lx0)>CHKMAX_X) return TRUE;
				if((lx2-lx0)>CHKMAX_X) return TRUE;
			}
		}
	}


	if(ly0<0)
	{
		if((ly1-ly0)>CHKMAX_Y) return TRUE;
		if((ly2-ly0)>CHKMAX_Y) return TRUE;
	}
	if(ly1<0)
	{
		if((ly0-ly1)>CHKMAX_Y) return TRUE;
		if((ly2-ly1)>CHKMAX_Y) return TRUE;
		if((ly3-ly1)>CHKMAX_Y) return TRUE;
	}
	if(ly2<0)
	{
		if((ly0-ly2)>CHKMAX_Y) return TRUE;
		if((ly1-ly2)>CHKMAX_Y) return TRUE;
		if((ly3-ly2)>CHKMAX_Y) return TRUE;
	}
	if(ly3<0)
	{
		if((ly1-ly3)>CHKMAX_Y) return TRUE;
		if((ly2-ly3)>CHKMAX_Y) return TRUE;
	}

	return FALSE;
}

__inline BOOL CheckCoord3()
{
	if(lx0<0)
	{
		if((lx1-lx0)>CHKMAX_X) return TRUE;
		if((lx2-lx0)>CHKMAX_X) return TRUE;
	}
	if(lx1<0)
	{
		if((lx0-lx1)>CHKMAX_X) return TRUE;
		if((lx2-lx1)>CHKMAX_X) return TRUE;
	}
	if(lx2<0)
	{
		if((lx0-lx2)>CHKMAX_X) return TRUE;
		if((lx1-lx2)>CHKMAX_X) return TRUE;
	}
	if(ly0<0)
	{
		if((ly1-ly0)>CHKMAX_Y) return TRUE;
		if((ly2-ly0)>CHKMAX_Y) return TRUE;
	}
	if(ly1<0)
	{
		if((ly0-ly1)>CHKMAX_Y) return TRUE;
		if((ly2-ly1)>CHKMAX_Y) return TRUE;
	}
	if(ly2<0)
	{
		if((ly0-ly2)>CHKMAX_Y) return TRUE;
		if((ly1-ly2)>CHKMAX_Y) return TRUE;
	}

	return FALSE;
}


__inline BOOL CheckCoord2()
{
	if(lx0<0)
	{
		if((lx1-lx0)>CHKMAX_X) return TRUE;
	}
	if(lx1<0)
	{
		if((lx0-lx1)>CHKMAX_X) return TRUE;
	}
	if(ly0<0)
	{
		if((ly1-ly0)>CHKMAX_Y) return TRUE;
	}
	if(ly1<0)
	{
		if((ly0-ly1)>CHKMAX_Y) return TRUE;
	}

	return FALSE;
}

__inline BOOL CheckCoordL(short slx0,short sly0,short slx1,short sly1)
{
	if(slx0<0)
	{
		if((slx1-slx0)>CHKMAX_X) return TRUE;
	}
	if(slx1<0)
	{
		if((slx0-slx1)>CHKMAX_X) return TRUE;
	}
	if(sly0<0)
	{
		if((sly1-sly0)>CHKMAX_Y) return TRUE;
	}
	if(sly1<0)
	{
		if((sly0-sly1)>CHKMAX_Y) return TRUE;
	}

	return FALSE;
}


////////////////////////////////////////////////////////////////////////
// mask stuff... used in silent hill
////////////////////////////////////////////////////////////////////////

void cmdSTP(unsigned char * baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	lGPUstatusRet&=~0x1800;                                   // Clear the necessary bits
	lGPUstatusRet|=((gdata & 0x03) << 11);                    // Set the necessary bits

	if(gdata&1) {sSetMask=0x8000;lSetMask=0x80008000;}
	else        {sSetMask=0;     lSetMask=0;         }

	if(gdata&2) bCheckMask=TRUE;
	else        bCheckMask=FALSE;
}

////////////////////////////////////////////////////////////////////////
// cmd: Set texture page infos
////////////////////////////////////////////////////////////////////////

void cmdTexturePage(unsigned char * baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	lGPUstatusRet&=~0x000007ff;
	lGPUstatusRet|=(gdata & 0x07ff);

	usMirror=(unsigned short)(gdata&0x3000);

	UpdateGlobalTP((unsigned short)gdata);
	GlobalTextREST = (gdata&0x00ffffff)>>9;
}

////////////////////////////////////////////////////////////////////////
// cmd: turn on/off texture window
////////////////////////////////////////////////////////////////////////

void cmdTextureWindow(unsigned char *baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	uint32_t YAlign,XAlign;

	lGPUInfoVals[INFO_TW]=gdata&0xFFFFF;

	if(gdata & 0x020)
		TWin.Position.y1 = 8;    // xxxx1
	else if (gdata & 0x040)
		TWin.Position.y1 = 16;   // xxx10
	else if (gdata & 0x080)
		TWin.Position.y1 = 32;   // xx100
	else if (gdata & 0x100)
		TWin.Position.y1 = 64;   // x1000
	else if (gdata & 0x200)
		TWin.Position.y1 = 128;  // 10000
	else
		TWin.Position.y1 = 256;  // 00000

	// Texture window size is determined by the least bit set of the relevant 5 bits

	if (gdata & 0x001)
		TWin.Position.x1 = 8;    // xxxx1
	else if (gdata & 0x002)
		TWin.Position.x1 = 16;   // xxx10
	else if (gdata & 0x004)
		TWin.Position.x1 = 32;   // xx100
	else if (gdata & 0x008)
		TWin.Position.x1 = 64;   // x1000
	else if (gdata & 0x010)
		TWin.Position.x1 = 128;  // 10000
	else
		TWin.Position.x1 = 256;  // 00000

	// Re-calculate the bit field, because we can't trust what is passed in the data


	YAlign = (uint32_t)(32 - (TWin.Position.y1 >> 3));
	XAlign = (uint32_t)(32 - (TWin.Position.x1 >> 3));

	// Absolute position of the start of the texture window

	TWin.Position.y0 = (short)(((gdata >> 15) & YAlign) << 3);
	TWin.Position.x0 = (short)(((gdata >> 10) & XAlign) << 3);

	if((TWin.Position.x0 == 0 &&                          // tw turned off
		TWin.Position.y0 == 0 &&
		TWin.Position.x1 == 0 &&
		TWin.Position.y1 == 0) ||  
		(TWin.Position.x1 == 256 &&
		TWin.Position.y1 == 256))
	{
		bUsingTWin = FALSE;                                 // -> just do it
	}                                                    
	else                                                  // otherwise
	{
		bUsingTWin = TRUE;                                  // -> tw turned on
	}
}

////////////////////////////////////////////////////////////////////////
// cmd: start of drawing area... primitives will be clipped inside
////////////////////////////////////////////////////////////////////////



void cmdDrawAreaStart(unsigned char * baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	drawX  = gdata & 0x3ff;                               // for soft drawing

	if(dwGPUVersion==2)
	{
		lGPUInfoVals[INFO_DRAWSTART]=gdata&0x3FFFFF;
		drawY  = (gdata>>12)&0x3ff;
		if(drawY>=1024) drawY=1023;                         // some security
	}
	else
	{
		lGPUInfoVals[INFO_DRAWSTART]=gdata&0xFFFFF;
		drawY  = (gdata>>10)&0x3ff;
		if(drawY>=512) drawY=511;                           // some security
	}
}

////////////////////////////////////////////////////////////////////////
// cmd: end of drawing area... primitives will be clipped inside
////////////////////////////////////////////////////////////////////////

void cmdDrawAreaEnd(unsigned char * baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	drawW  = gdata & 0x3ff;                               // for soft drawing

	if(dwGPUVersion==2)
	{
		lGPUInfoVals[INFO_DRAWEND]=gdata&0x3FFFFF;
		drawH  = (gdata>>12)&0x3ff;
		if(drawH>=1024) drawH=1023;                         // some security
	}
	else
	{
		lGPUInfoVals[INFO_DRAWEND]=gdata&0xFFFFF;
		drawH  = (gdata>>10)&0x3ff;
		if(drawH>=512) drawH=511;                           // some security
	}
}

////////////////////////////////////////////////////////////////////////
// cmd: draw offset... will be added to prim coords
////////////////////////////////////////////////////////////////////////

void cmdDrawOffset(unsigned char * baseAddr)
{
	uint32_t gdata = GETLE32(&((uint32_t*)baseAddr)[0]);

	PSXDisplay.DrawOffset.x = (short)(gdata & 0x7ff);

	if(dwGPUVersion==2)
	{
		lGPUInfoVals[INFO_DRAWOFF]=gdata&0x7FFFFF;
		PSXDisplay.DrawOffset.y = (short)((gdata>>12) & 0x7ff);
	}
	else
	{
		lGPUInfoVals[INFO_DRAWOFF]=gdata&0x3FFFFF;
		PSXDisplay.DrawOffset.y = (short)((gdata>>11) & 0x7ff);
	}

	PSXDisplay.DrawOffset.y=(short)(((int)PSXDisplay.DrawOffset.y<<21)>>21);
	PSXDisplay.DrawOffset.x=(short)(((int)PSXDisplay.DrawOffset.x<<21)>>21);
}

////////////////////////////////////////////////////////////////////////
// cmd: load image to vram
////////////////////////////////////////////////////////////////////////

void primLoadImage(unsigned char * baseAddr)
{
	unsigned short *sgpuData = ((unsigned short *) baseAddr);

	VRAMWrite.x      = GETLEs16(&sgpuData[2])&0x3ff;
	VRAMWrite.y      = GETLEs16(&sgpuData[3])&iGPUHeightMask;
	VRAMWrite.Width  = GETLEs16(&sgpuData[4]);
	VRAMWrite.Height = GETLEs16(&sgpuData[5]);

	DataWriteMode = DR_VRAMTRANSFER;

	VRAMWrite.ImagePtr = psxVuw + (VRAMWrite.y<<10) + VRAMWrite.x;
	VRAMWrite.RowsRemaining = VRAMWrite.Width;
	VRAMWrite.ColsRemaining = VRAMWrite.Height;
}

////////////////////////////////////////////////////////////////////////
// cmd: vram -> psx mem
////////////////////////////////////////////////////////////////////////

void primStoreImage(unsigned char * baseAddr)
{
	unsigned short *sgpuData = ((unsigned short *) baseAddr);

	VRAMRead.x      = GETLEs16(&sgpuData[2])&0x03ff;
	VRAMRead.y      = GETLEs16(&sgpuData[3])&iGPUHeightMask;
	VRAMRead.Width  = GETLEs16(&sgpuData[4]);
	VRAMRead.Height = GETLEs16(&sgpuData[5]);

	VRAMRead.ImagePtr = psxVuw + (VRAMRead.y<<10) + VRAMRead.x;
	VRAMRead.RowsRemaining = VRAMRead.Width;
	VRAMRead.ColsRemaining = VRAMRead.Height;

	DataReadMode = DR_VRAMTRANSFER;

	lGPUstatusRet |= GPUSTATUS_READYFORVRAM;
}

////////////////////////////////////////////////////////////////////////
// cmd: blkfill - NO primitive! Doesn't care about draw areas...
////////////////////////////////////////////////////////////////////////

void primBlkFill(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	short sX = GETLEs16(&sgpuData[2]);
	short sY = GETLEs16(&sgpuData[3]);
	short sW = GETLEs16(&sgpuData[4]) & 0x3ff;
	short sH = GETLEs16(&sgpuData[5]) & 0x3ff;

	sW = (sW+15) & ~15;

	// Increase H & W if they are one short of full values, because they never can be full values
	if (sH >= 1023) sH=1024;
	if (sW >= 1023) sW=1024; 

	// x and y of end pos
	sW+=sX;
	sH+=sY;

	FillSoftwareArea(sX, sY, sW, sH, BGR24to16(GETLE32(&gpuData[0])));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: move image vram -> vram
////////////////////////////////////////////////////////////////////////

void primMoveImage(unsigned char * baseAddr)
{
	short *sgpuData = ((short *) baseAddr);

	short imageY0,imageX0,imageY1,imageX1,imageSX,imageSY,i,j;

	imageX0 = GETLEs16(&sgpuData[2])&0x03ff;
	imageY0 = GETLEs16(&sgpuData[3])&iGPUHeightMask;
	imageX1 = GETLEs16(&sgpuData[4])&0x03ff;
	imageY1 = GETLEs16(&sgpuData[5])&iGPUHeightMask;
	imageSX = GETLEs16(&sgpuData[6]);
	imageSY = GETLEs16(&sgpuData[7]);

	if((imageX0 == imageX1) && (imageY0 == imageY1)) return; 
	if(imageSX<=0)  return;
	if(imageSY<=0)  return;

	// ZN SF2: screwed moves
	// 
	// move sgpuData[2],sgpuData[3],sgpuData[4],sgpuData[5],sgpuData[6],sgpuData[7]
	// 
	// move 365 182 32723 -21846 17219  15427
	// move 127 160 147   -1     20817  13409
	// move 141 165 16275 -21862 -32126 13442
	// move 161 136 24620 -1     16962  13388
	// move 168 138 32556 -13090 -29556 15500
	//
	// and here's the hack for it:

	if(iGPUHeight==1024 && GETLEs16(&sgpuData[7])>1024) return;

	if((imageY0+imageSY)>iGPUHeight ||
		(imageX0+imageSX)>1024       ||
		(imageY1+imageSY)>iGPUHeight ||
		(imageX1+imageSX)>1024)
	{
		int i,j;
		for(j=0;j<imageSY;j++)
			for(i=0;i<imageSX;i++)
				psxVuw [(1024*((imageY1+j)&iGPUHeightMask))+((imageX1+i)&0x3ff)]=
				psxVuw[(1024*((imageY0+j)&iGPUHeightMask))+((imageX0+i)&0x3ff)];

		bDoVSyncUpdate=TRUE;

		return;
	}

	if(imageSX&1)                                         // not dword aligned? slower func
	{
		unsigned short *SRCPtr, *DSTPtr;
		unsigned short LineOffset;

		SRCPtr = psxVuw + (1024*imageY0) + imageX0;
		DSTPtr = psxVuw + (1024*imageY1) + imageX1;

		LineOffset = 1024 - imageSX;

		for(j=0;j<imageSY;j++)
		{
			for(i=0;i<imageSX;i++) *DSTPtr++ = *SRCPtr++;
			SRCPtr += LineOffset;
			DSTPtr += LineOffset;
		}
	}
	else                                                  // dword aligned
	{
		uint32_t *SRCPtr, *DSTPtr;
		unsigned short LineOffset;
		int dx=imageSX>>1;

		SRCPtr = (uint32_t *)(psxVuw + (1024*imageY0) + imageX0);
		DSTPtr = (uint32_t *)(psxVuw + (1024*imageY1) + imageX1);

		LineOffset = 512 - dx;

		for(j=0;j<imageSY;j++)
		{
			for(i=0;i<dx;i++) *DSTPtr++ = *SRCPtr++;
			SRCPtr += LineOffset;
			DSTPtr += LineOffset;
		}
	}

	imageSX+=imageX1;
	imageSY+=imageY1;

	/*
	if(!PSXDisplay.Interlaced)                            // stupid frame skip stuff
	{
	if(UseFrameSkip &&
	imageX1<PSXDisplay.DisplayEnd.x &&
	imageSX>=PSXDisplay.DisplayPosition.x &&
	imageY1<PSXDisplay.DisplayEnd.y &&
	imageSY>=PSXDisplay.DisplayPosition.y)
	updateDisplay();
	}
	*/

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: draw free-size Tile 
////////////////////////////////////////////////////////////////////////

//#define SMALLDEBUG
//#include <dbgout.h>

void primTileS(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t*)baseAddr);
	short *sgpuData = ((short *) baseAddr);
	short sW = GETLEs16(&sgpuData[4]) & 0x3ff;
	short sH = GETLEs16(&sgpuData[5]) & iGPUHeightMask;              // mmm... limit tiles to 0x1ff or height?

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	// x and y of start
	ly2 = ly3 = ly0+sH +PSXDisplay.DrawOffset.y;
	ly0 = ly1 = ly0    +PSXDisplay.DrawOffset.y;
	lx1 = lx2 = lx0+sW +PSXDisplay.DrawOffset.x;
	lx0 = lx3 = lx0    +PSXDisplay.DrawOffset.x;

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	if(!(iTileCheat && sH==32 && GETLE32(&gpuData[0])==0x60ffffff)) // special cheat for certain ZiNc games
		FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
		BGR24to16(GETLE32(&gpuData[0])));          

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: draw 1 dot Tile (point)
////////////////////////////////////////////////////////////////////////

void primTile1(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t*)baseAddr);
	short *sgpuData = ((short *) baseAddr);
	short sH = 1;
	short sW = 1;

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	// x and y of start
	ly2 = ly3 = ly0+sH +PSXDisplay.DrawOffset.y;
	ly0 = ly1 = ly0    +PSXDisplay.DrawOffset.y;
	lx1 = lx2 = lx0+sW +PSXDisplay.DrawOffset.x;
	lx0 = lx3 = lx0    +PSXDisplay.DrawOffset.x;

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
		BGR24to16(GETLE32(&gpuData[0])));          // Takes Start and Offset

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: draw 8 dot Tile (small rect)
////////////////////////////////////////////////////////////////////////

void primTile8(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t*)baseAddr);
	short *sgpuData = ((short *) baseAddr);
	short sH = 8;
	short sW = 8;

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	// x and y of start
	ly2 = ly3 = ly0+sH +PSXDisplay.DrawOffset.y;
	ly0 = ly1 = ly0    +PSXDisplay.DrawOffset.y;
	lx1 = lx2 = lx0+sW +PSXDisplay.DrawOffset.x;
	lx0 = lx3 = lx0    +PSXDisplay.DrawOffset.x;

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
		BGR24to16(GETLE32(&gpuData[0])));          // Takes Start and Offset

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: draw 16 dot Tile (medium rect)
////////////////////////////////////////////////////////////////////////

void primTile16(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t*)baseAddr);
	short *sgpuData = ((short *) baseAddr);
	short sH = 16;
	short sW = 16;

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	// x and y of start
	ly2 = ly3 = ly0+sH +PSXDisplay.DrawOffset.y;
	ly0 = ly1 = ly0    +PSXDisplay.DrawOffset.y;
	lx1 = lx2 = lx0+sW +PSXDisplay.DrawOffset.x;
	lx0 = lx3 = lx0    +PSXDisplay.DrawOffset.x;

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	FillSoftwareAreaTrans(lx0,ly0,lx2,ly2,
		BGR24to16(GETLE32(&gpuData[0])));          // Takes Start and Offset

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: small sprite (textured rect)
////////////////////////////////////////////////////////////////////////

void primSprt8(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	SetRenderMode(GETLE32(&gpuData[0]));

	if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,8,8);
	else
		if(usMirror)   DrawSoftwareSpriteMirror(baseAddr,8,8);
		else           DrawSoftwareSprite(baseAddr,8,8,
			baseAddr[8],
			baseAddr[9]);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: medium sprite (textured rect)
////////////////////////////////////////////////////////////////////////

void primSprt16(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	SetRenderMode(GETLE32(&gpuData[0]));

	if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,16,16);
	else
		if(usMirror)   DrawSoftwareSpriteMirror(baseAddr,16,16);
		else           DrawSoftwareSprite(baseAddr,16,16,
			baseAddr[8],
			baseAddr[9]);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: free-size sprite (textured rect)
////////////////////////////////////////////////////////////////////////

// func used on texture coord wrap
void primSprtSRest(unsigned char * baseAddr,unsigned short type)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);
	unsigned short sTypeRest=0;

	short s;
	short sX = GETLEs16(&sgpuData[2]);
	short sY = GETLEs16(&sgpuData[3]);
	short sW = GETLEs16(&sgpuData[6]) & 0x3ff;
	short sH = GETLEs16(&sgpuData[7]) & 0x1ff;
	short tX = baseAddr[8];
	short tY = baseAddr[9];

	switch(type)
	{
	case 1:
		s=256-baseAddr[8];
		sW-=s;
		sX+=s;
		tX=0;
		break;
	case 2:
		s=256-baseAddr[9];
		sH-=s;
		sY+=s;
		tY=0;
		break;
	case 3:
		s=256-baseAddr[8];
		sW-=s;
		sX+=s;
		tX=0;
		s=256-baseAddr[9];
		sH-=s;
		sY+=s;
		tY=0;
		break;
	case 4:
		s=512-baseAddr[8];
		sW-=s;
		sX+=s;
		tX=0;
		break;
	case 5:
		s=512-baseAddr[9];
		sH-=s;
		sY+=s;
		tY=0;
		break;
	case 6:
		s=512-baseAddr[8];
		sW-=s;
		sX+=s;
		tX=0;
		s=512-baseAddr[9];
		sH-=s;
		sY+=s;
		tY=0;
		break;
	}

	SetRenderMode(GETLE32(&gpuData[0]));

	if(tX+sW>256) {sW=256-tX;sTypeRest+=1;}
	if(tY+sH>256) {sH=256-tY;sTypeRest+=2;}

	lx0 = sX;
	ly0 = sY;

	if(!(dwActFixes&8)) AdjustCoord1();

	DrawSoftwareSprite(baseAddr,sW,sH,tX,tY);

	if(sTypeRest && type<4)  
	{
		if(sTypeRest&1  && type==1)  primSprtSRest(baseAddr,4);
		if(sTypeRest&2  && type==2)  primSprtSRest(baseAddr,5);
		if(sTypeRest==3 && type==3)  primSprtSRest(baseAddr,6);
	}

}

////////////////////////////////////////////////////////////////////////

void primSprtS(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);
	short sW,sH;


	//return;

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);

	if(!(dwActFixes&8)) AdjustCoord1();

	sW = GETLEs16(&sgpuData[6]) & 0x3ff;
	sH = GETLEs16(&sgpuData[7]) & 0x1ff;

	SetRenderMode(GETLE32(&gpuData[0]));

	if(bUsingTWin) DrawSoftwareSpriteTWin(baseAddr,sW,sH);
	else
		if(usMirror)   DrawSoftwareSpriteMirror(baseAddr,sW,sH);
		else          
		{
			unsigned short sTypeRest=0;
			short tX=baseAddr[8];
			short tY=baseAddr[9];

			if(tX+sW>256) {sW=256-tX;sTypeRest+=1;}
			if(tY+sH>256) {sH=256-tY;sTypeRest+=2;}

			DrawSoftwareSprite(baseAddr,sW,sH,tX,tY);

			if(sTypeRest) 
			{
				if(sTypeRest&1)  primSprtSRest(baseAddr,1);
				if(sTypeRest&2)  primSprtSRest(baseAddr,2);
				if(sTypeRest==3) primSprtSRest(baseAddr,3);
			}

		}

		bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: flat shaded Poly4
////////////////////////////////////////////////////////////////////////

void primPolyF4(unsigned char *baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[4]);
	ly1 = GETLEs16(&sgpuData[5]);
	lx2 = GETLEs16(&sgpuData[6]);
	ly2 = GETLEs16(&sgpuData[7]);
	lx3 = GETLEs16(&sgpuData[8]);
	ly3 = GETLEs16(&sgpuData[9]);

	if(!(dwActFixes&8)) 
	{
		AdjustCoord4();
		if(CheckCoord4()) return;
	}

	offsetPSX4();
	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	drawPoly4F(GETLE32(&gpuData[0]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: smooth shaded Poly4
////////////////////////////////////////////////////////////////////////

void primPolyG4(unsigned char * baseAddr)
{
	uint32_t *gpuData = (uint32_t *)baseAddr;
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[6]);
	ly1 = GETLEs16(&sgpuData[7]);
	lx2 = GETLEs16(&sgpuData[10]);
	ly2 = GETLEs16(&sgpuData[11]);
	lx3 = GETLEs16(&sgpuData[14]);
	ly3 = GETLEs16(&sgpuData[15]);

	if(!(dwActFixes&8))
	{
		AdjustCoord4();
		if(CheckCoord4()) return;
	}

	offsetPSX4();
	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	drawPoly4G(GETLE32(&gpuData[0]), GETLE32(&gpuData[2]), 
		GETLE32(&gpuData[4]), GETLE32(&gpuData[6]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: flat shaded Texture3
////////////////////////////////////////////////////////////////////////

void primPolyFT3(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[6]);
	ly1 = GETLEs16(&sgpuData[7]);
	lx2 = GETLEs16(&sgpuData[10]);
	ly2 = GETLEs16(&sgpuData[11]);

	lLowerpart=GETLE32(&gpuData[4])>>16;
	UpdateGlobalTP((unsigned short)lLowerpart);

	if(!(dwActFixes&8))
	{
		AdjustCoord3();
		if(CheckCoord3()) return;
	}

	offsetPSX3();
	SetRenderMode(GETLE32(&gpuData[0]));

	drawPoly3FT(baseAddr);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: flat shaded Texture4
////////////////////////////////////////////////////////////////////////

void primPolyFT4(unsigned char * baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[6]);
	ly1 = GETLEs16(&sgpuData[7]);
	lx2 = GETLEs16(&sgpuData[10]);
	ly2 = GETLEs16(&sgpuData[11]);
	lx3 = GETLEs16(&sgpuData[14]);
	ly3 = GETLEs16(&sgpuData[15]);

	lLowerpart=GETLE32(&gpuData[4])>>16;
	UpdateGlobalTP((unsigned short)lLowerpart);

	if(!(dwActFixes&8))
	{
		AdjustCoord4();
		if(CheckCoord4()) return;
	}

	offsetPSX4();

	SetRenderMode(GETLE32(&gpuData[0]));

	drawPoly4FT(baseAddr);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: smooth shaded Texture3
////////////////////////////////////////////////////////////////////////

void primPolyGT3(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[8]);
	ly1 = GETLEs16(&sgpuData[9]);
	lx2 = GETLEs16(&sgpuData[14]);
	ly2 = GETLEs16(&sgpuData[15]);

	lLowerpart=GETLE32(&gpuData[5])>>16;
	UpdateGlobalTP((unsigned short)lLowerpart);

	if(!(dwActFixes&8))
	{
		AdjustCoord3();
		if(CheckCoord3()) return;
	}

	offsetPSX3();
	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	if(SHADETEXBIT(GETLE32(&gpuData[0])))
	{
		gpuData[0] = (gpuData[0]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
		gpuData[3] = (gpuData[3]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
		gpuData[6] = (gpuData[6]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
	}

	drawPoly3GT(baseAddr);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: smooth shaded Poly3
////////////////////////////////////////////////////////////////////////

void primPolyG3(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[6]);
	ly1 = GETLEs16(&sgpuData[7]);
	lx2 = GETLEs16(&sgpuData[10]);
	ly2 = GETLEs16(&sgpuData[11]);

	if(!(dwActFixes&8))
	{
		AdjustCoord3();
		if(CheckCoord3()) return;
	}

	offsetPSX3();
	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	drawPoly3G(GETLE32(&gpuData[0]), GETLE32(&gpuData[2]), GETLE32(&gpuData[4]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: smooth shaded Texture4
////////////////////////////////////////////////////////////////////////

void primPolyGT4(unsigned char *baseAddr)
{ 
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[8]);
	ly1 = GETLEs16(&sgpuData[9]);
	lx2 = GETLEs16(&sgpuData[14]);
	ly2 = GETLEs16(&sgpuData[15]);
	lx3 = GETLEs16(&sgpuData[20]);
	ly3 = GETLEs16(&sgpuData[21]);

	lLowerpart=GETLE32(&gpuData[5])>>16;
	UpdateGlobalTP((unsigned short)lLowerpart);

	if(!(dwActFixes&8))
	{
		AdjustCoord4();
		if(CheckCoord4()) return;
	}

	offsetPSX4();
	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	if(SHADETEXBIT(GETLE32(&gpuData[0])))
	{
		gpuData[0] = (gpuData[0]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
		gpuData[3] = (gpuData[3]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
		gpuData[6] = (gpuData[6]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
		gpuData[9] = (gpuData[9]&HOST2LE32(0xff000000))|HOST2LE32(0x00808080);
	}

	drawPoly4GT(baseAddr);

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: smooth shaded Poly3
////////////////////////////////////////////////////////////////////////

void primPolyF3(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[4]);
	ly1 = GETLEs16(&sgpuData[5]);
	lx2 = GETLEs16(&sgpuData[6]);
	ly2 = GETLEs16(&sgpuData[7]);

	if(!(dwActFixes&8))
	{
		AdjustCoord3();
		if(CheckCoord3()) return;
	}

	offsetPSX3();
	SetRenderMode(GETLE32(&gpuData[0]));

	drawPoly3F(GETLE32(&gpuData[0]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: skipping shaded polylines
////////////////////////////////////////////////////////////////////////

void primLineGSkip(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	int iMax=255;
	int i=2;

	ly1 = (short)((GETLE32(&gpuData[1])>>16) & 0xffff);
	lx1 = (short)(GETLE32(&gpuData[1]) & 0xffff);

	while(!(((GETLE32(&gpuData[i]) & 0xF000F000) == 0x50005000) && i>=4))
	{
		i++;
		ly1 = (short)((GETLE32(&gpuData[i])>>16) & 0xffff);
		lx1 = (short)(GETLE32(&gpuData[i]) & 0xffff);
		i++;if(i>iMax) break;
	}
}

////////////////////////////////////////////////////////////////////////
// cmd: shaded polylines
////////////////////////////////////////////////////////////////////////

void primLineGEx(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	int iMax=255;
	uint32_t lc0,lc1;
	short slx0,slx1,sly0,sly1;int i=2;BOOL bDraw=TRUE;

	sly1 = (short)((GETLE32(&gpuData[1])>>16) & 0xffff);
	slx1 = (short)(GETLE32(&gpuData[1]) & 0xffff);

	if(!(dwActFixes&8)) 
	{
		slx1=(short)(((int)slx1<<SIGNSHIFT)>>SIGNSHIFT);
		sly1=(short)(((int)sly1<<SIGNSHIFT)>>SIGNSHIFT);
	}

	lc1 = gpuData[0] & 0xffffff;

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;

	while(!(((GETLE32(&gpuData[i]) & 0xF000F000) == 0x50005000) && i>=4))
	{
		sly0=sly1; slx0=slx1; lc0=lc1;
		lc1=GETLE32(&gpuData[i]) & 0xffffff;

		i++;

		// no check needed on gshaded polyline positions
		// if((gpuData[i] & 0xF000F000) == 0x50005000) break;

		sly1 = (short)((GETLE32(&gpuData[i])>>16) & 0xffff);
		slx1 = (short)(GETLE32(&gpuData[i]) & 0xffff);

		if(!(dwActFixes&8))
		{
			slx1=(short)(((int)slx1<<SIGNSHIFT)>>SIGNSHIFT);
			sly1=(short)(((int)sly1<<SIGNSHIFT)>>SIGNSHIFT);
			if(CheckCoordL(slx0,sly0,slx1,sly1)) bDraw=FALSE; else bDraw=TRUE;
		}

		if ((lx0 != lx1) || (ly0 != ly1))
		{
			ly0=sly0;
			lx0=slx0;
			ly1=sly1;
			lx1=slx1;

			offsetPSX2();
			if(bDraw) DrawSoftwareLineShade(lc0, lc1);
		}
		i++;  
		if(i>iMax) break;
	}

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: shaded polyline2
////////////////////////////////////////////////////////////////////////

void primLineG2(unsigned char *baseAddr)
{    
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[6]);
	ly1 = GETLEs16(&sgpuData[7]);

	if(!(dwActFixes&8))
	{
		AdjustCoord2();
		if(CheckCoord2()) return;
	}

	if((lx0 == lx1) && (ly0 == ly1)) {lx1++;ly1++;}

	DrawSemiTrans = (SEMITRANSBIT(GETLE32(&gpuData[0]))) ? TRUE : FALSE;
	offsetPSX2();
	DrawSoftwareLineShade(GETLE32(&gpuData[0]),GETLE32(&gpuData[2]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: skipping flat polylines
////////////////////////////////////////////////////////////////////////

void primLineFSkip(unsigned char *baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	int i=2,iMax=255;

	ly1 = (short)((GETLE32(&gpuData[1])>>16) & 0xffff);
	lx1 = (short)(GETLE32(&gpuData[1]) & 0xffff);

	while(!(((GETLE32(&gpuData[i]) & 0xF000F000) == 0x50005000) && i>=3))
	{
		ly1 = (short)((GETLE32(&gpuData[i])>>16) & 0xffff);
		lx1 = (short)(GETLE32(&gpuData[i]) & 0xffff);
		i++;if(i>iMax) break;
	}             
}

////////////////////////////////////////////////////////////////////////
// cmd: drawing flat polylines
////////////////////////////////////////////////////////////////////////

void primLineFEx(unsigned char *baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	int iMax;
	short slx0,slx1,sly0,sly1;int i=2;BOOL bDraw=TRUE;

	iMax=255;

	sly1 = (short)((GETLE32(&gpuData[1])>>16) & 0xffff);
	slx1 = (short)(GETLE32(&gpuData[1]) & 0xffff);
	if(!(dwActFixes&8))
	{
		slx1=(short)(((int)slx1<<SIGNSHIFT)>>SIGNSHIFT);
		sly1=(short)(((int)sly1<<SIGNSHIFT)>>SIGNSHIFT);
	}

	SetRenderMode(GETLE32(&gpuData[0]));

	while(!(((GETLE32(&gpuData[i]) & 0xF000F000) == 0x50005000) && i>=3))
	{
		sly0 = sly1;slx0=slx1;
		sly1 = (short)((GETLE32(&gpuData[i])>>16) & 0xffff);
		slx1 = (short)(GETLE32(&gpuData[i]) & 0xffff);
		if(!(dwActFixes&8))
		{
			slx1=(short)(((int)slx1<<SIGNSHIFT)>>SIGNSHIFT);
			sly1=(short)(((int)sly1<<SIGNSHIFT)>>SIGNSHIFT);

			if(CheckCoordL(slx0,sly0,slx1,sly1)) bDraw=FALSE; else bDraw=TRUE;
		}

		ly0=sly0;
		lx0=slx0;
		ly1=sly1;
		lx1=slx1;

		offsetPSX2();
		if(bDraw) DrawSoftwareLineFlat(GETLE32(&gpuData[0]));

		i++;if(i>iMax) break;
	}

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: drawing flat polyline2
////////////////////////////////////////////////////////////////////////

void primLineF2(unsigned char *baseAddr)
{
	uint32_t *gpuData = ((uint32_t *) baseAddr);
	short *sgpuData = ((short *) baseAddr);

	lx0 = GETLEs16(&sgpuData[2]);
	ly0 = GETLEs16(&sgpuData[3]);
	lx1 = GETLEs16(&sgpuData[4]);
	ly1 = GETLEs16(&sgpuData[5]);

	if(!(dwActFixes&8))
	{
		AdjustCoord2();
		if(CheckCoord2()) return;
	}

	if((lx0 == lx1) && (ly0 == ly1)) {lx1++;ly1++;}

	offsetPSX2();
	SetRenderMode(GETLE32(&gpuData[0]));

	DrawSoftwareLineFlat(GETLE32(&gpuData[0]));

	bDoVSyncUpdate=TRUE;
}

////////////////////////////////////////////////////////////////////////
// cmd: well, easiest command... not implemented
////////////////////////////////////////////////////////////////////////

void primNI(unsigned char *bA)
{
}

////////////////////////////////////////////////////////////////////////
// cmd func ptr table
////////////////////////////////////////////////////////////////////////


void (*primTableJ[256])(unsigned char *) = 
{
	// 00
	primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
	// 08
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 10
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 18
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 20
	primPolyF3,primPolyF3,primPolyF3,primPolyF3,primPolyFT3,primPolyFT3,primPolyFT3,primPolyFT3,
	// 28
	primPolyF4,primPolyF4,primPolyF4,primPolyF4,primPolyFT4,primPolyFT4,primPolyFT4,primPolyFT4,
	// 30
	primPolyG3,primPolyG3,primPolyG3,primPolyG3,primPolyGT3,primPolyGT3,primPolyGT3,primPolyGT3,
	// 38
	primPolyG4,primPolyG4,primPolyG4,primPolyG4,primPolyGT4,primPolyGT4,primPolyGT4,primPolyGT4,
	// 40
	primLineF2,primLineF2,primLineF2,primLineF2,primNI,primNI,primNI,primNI,
	// 48
	primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,primLineFEx,
	// 50
	primLineG2,primLineG2,primLineG2,primLineG2,primNI,primNI,primNI,primNI,
	// 58
	primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,primLineGEx,
	// 60
	primTileS,primTileS,primTileS,primTileS,primSprtS,primSprtS,primSprtS,primSprtS,
	// 68
	primTile1,primTile1,primTile1,primTile1,primNI,primNI,primNI,primNI,
	// 70
	primTile8,primTile8,primTile8,primTile8,primSprt8,primSprt8,primSprt8,primSprt8,
	// 78
	primTile16,primTile16,primTile16,primTile16,primSprt16,primSprt16,primSprt16,primSprt16,
	// 80
	primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 88
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 90
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 98
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// a0
	primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// a8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// b0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// b8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// c0
	primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// c8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// d0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// d8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// e0
	primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
	// e8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// f0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// f8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
};

////////////////////////////////////////////////////////////////////////
// cmd func ptr table for skipping
////////////////////////////////////////////////////////////////////////

void (*primTableSkip[256])(unsigned char *) = 
{
	// 00
	primNI,primNI,primBlkFill,primNI,primNI,primNI,primNI,primNI,
	// 08
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 10
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 18
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 20
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 28
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 30
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 38
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 40
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 48
	primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,primLineFSkip,
	// 50
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 58
	primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,primLineGSkip,
	// 60
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 68
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 70
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 78
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 80
	primMoveImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 88
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 90
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// 98
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// a0
	primLoadImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// a8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// b0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// b8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// c0
	primStoreImage,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// c8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// d0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// d8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// e0
	primNI,cmdTexturePage,cmdTextureWindow,cmdDrawAreaStart,cmdDrawAreaEnd,cmdDrawOffset,cmdSTP,primNI,
	// e8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// f0
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI,
	// f8
	primNI,primNI,primNI,primNI,primNI,primNI,primNI,primNI
};
